
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Clases;

/**
 *
 * @author PC
 */
public class Calculos {

    //*********************************** PARAMETROS *************************************//
    /*
     ** Altura de Montaje: alturaDeMontaje double (Metros sobre el nivel del mar: msnm)   **
     ** Temperatura Promedio: temperaturaPromedio double (Grados Celcius)                 **
     ** Numero de Diametros: numeroDeDiametros double (Adimensional)                      **
     ** Bil Basico: bilBasico double (kiloVoltios kV)                                     ** 
     ** Voltaje Nominal: voltajeNominal double (kiloVoltios kV)                           */
    //*********************************** TABLAS *****************************************//
    /* 
     * -PRESION
     * -Hg
     * -BIL Maximo
     * -Voltaje Maximo
     */
    //***************************** VARIABLES GLOBALES ************************************//
    private double alturaMontaje;
    private double temperaturaPromedio;
    private double numeroDeDiametros;
    private double bilBasico;
    private double voltajeNominal;
    private double presion;
    private double hg;
    private double bilMaximo;
    private double voltajeMaximo;
    private double factorAutomatico1;
    private double factorAutomatico2;

    /**
     * Constructor Vacio
     */
    public Calculos() {
    }

    /**
     * Constructor vacio que recibe todos los parametros necesarios para hacer
     * los calculos.
     *
     * @param alturaDeMontaje Altura del montaje
     * @param temperaturaPromedio Temperatura Promedio
     * @param numeroDeDiametros Numero de Diametros
     * @param bilBasico BIL Basico
     * @param voltajeNominal Voltaje Nomial
     * @param presion Presion (Este valor se extrae de la tabla estandar de
     * presiones)
     * @param hg
     * @param bilMaximo BIL Maximo Aceptado
     * @param voltajeMaximo Voltaje Maximo Aceptado
     */
    public Calculos(double alturaDeMontaje, double temperaturaPromedio, double numeroDeDiametros, double bilBasico, double voltajeNominal,
            double presion, double hg, double bilMaximo, double voltajeMaximo) {
        //asignacion de variables globales
        this.alturaMontaje = alturaDeMontaje;
        this.temperaturaPromedio = temperaturaPromedio;
        this.numeroDeDiametros = numeroDeDiametros;
        this.bilBasico = bilBasico;
        this.voltajeNominal = voltajeNominal;
        this.presion = presion;
        this.hg = hg;
        this.bilMaximo = bilMaximo;
        this.voltajeMaximo = voltajeMaximo;

        //seteamos las variables automaticas, generadas a partir de los parametros
        //factorAutomatico1 y factorAutomatico2
        if (voltajeNominal <= 230) {
            factorAutomatico1 = 1.1;
            factorAutomatico2 = 0.961;
        } else {
            factorAutomatico1 = 1.06;
            factorAutomatico2 = 0.922;
        }



        //proceso de calculo

    }
//INICIO DE: DISTANCIA DE FASE A TIERRA BIL BASICO  

    /**
     * Calcula la densidad en base a la temperatura promedio y la presion
     *
     * @param temperaturaPromedio: temperatura promedio
     * @param valorTablaPresion: valor de la tabla de presion
     * @Observation Formula: (3.92*PRESION/10)/(273+TEMPERATURA_PROMEDIO)
     * @return resultado: Resultado de la operacion, si retorna -1 hay error;
     *
     */
    public double Densidad(double temperaturaPromedio, double valorTablaPresion) throws Exception {
        double resultado = (double) -1;
        double constante = (double) 3.92;
        try {
            //iniciamos calculos
            resultado = (constante * valorTablaPresion / 10) / (273 + temperaturaPromedio);
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando la Densidad");
        }
        return resultado;
    }

    /**
     * Metodo para calcular dft
     *
     * @param bilBasico
     * @param valorTablaHg
     * @param factorAutomatico1
     * @param factorAutomatico2
     * @param densidad
     * @return resultado: Resultado de la operacion, si retorna -1 hay error;
     * @Observation Formula: (BIL BASICO * VALOR HG DE TABLA * FACTOR AUTOMATICO
     * 1)/(FACTOR AUTOMATICO 2 * DENSIDAD *550)
     */
    public double dft(double bilBasico, double valorTablaHg, double densidad) throws Exception {
        double resultado = (double) -1;
        try {
            resultado = (bilBasico * valorTablaHg * factorAutomatico1) / (factorAutomatico2 * densidad * 550);
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando la dft");
        }
        return resultado;
    }

    /**
     *
     * @param dft numero dft devuelto en la funcion dft
     * @return resultado
     * @throws Exception
     */
    public double dff(double dft) throws Exception {
        double resultado = (double) -1;
        try {
            resultado = (dft * 1.15);
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando la dft");
        }
        return resultado;
    }

    /**
     * Metodo para calcular Y en Distancia de Fase a Tierra Bil Basico
     *
     * @param dff
     * @param dft
     * @return resultado
     * @Observation Formula: √(1/√2+dff+dft)²-(dft+0.5)²
     */
    public double Y_FaseATierra_BilBasico(double dff, double dft) throws Exception {
        double resultado = -1;
        try {
            double factor1 = Math.pow((1 / Math.sqrt(2) + dff + dft), 2);
            double factor2 = Math.pow((dft + 0.5), 2);
            resultado = Math.sqrt(factor1 - factor2);
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando Y");
        }
        return resultado;
    }

    /**
     * Metodo para calcular H en Distancia de Fase a Tierra con Bil Basico
     *
     * @param y_fase_tierra
     * @param hbmsnm
     * @return
     * @throws Exception
     */
    public double H_FaseATierra_BilBasico(double y_fase_tierra, double hbmsnm) throws Exception {
        double resultado = -1;
        try {
            resultado = y_fase_tierra + hbmsnm;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando H");
        }
        return resultado = -1;
    }

    //DISTANCIA DE FASE A TIERRA ENTRE POLOS ABIERTOS		
    /**
     * Metodo para calcular el DFT entre Polos Abiertos
     *
     * @param bilMaximo
     * @param hg
     * @param densidad
     * @return
     * @throws Exception
     */
    public double dft_polosAbiertos(double bilMaximo, double hg, double densidad) throws Exception {
        double resultado = -1;
        //(BilMaximo*hg*factorAutomatico1)/(factorAutomatico2*Densidad*550)
        try {
            resultado = (bilMaximo * hg * factorAutomatico1) / (factorAutomatico2 * densidad * 550);
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando dft entre polos abiertos.");
        }
        return resultado;
    }

    //DISTANCIA ENTRE BUSES
    /**
     * Metodo para calcular la distancia entre buses
     *
     * @param dft
     * @return
     * @throws Exception
     */
    public double dbb_1_8(double dft) throws Exception {
        double resultado = -1;
        try {
            resultado = dft * 1.8;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando dft entre polos abiertos.");
        }
        return resultado;
    }

    /**
     *
     * @param dbb_1_8
     * @param dft
     * @return
     * @throws Exception
     */
    public double distancia_dbb_1_8(double dbb_1_8, double dft) throws Exception {
        //dbb_1_8*2+dft*2+1
        double resultado = -1;
        try {
            resultado = dbb_1_8 * 2 + dft * 2 + 1;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando distancia de barra total con 1.8 .");
        }
        return resultado;
    }

    /**
     *
     * @param dft
     * @return
     * @throws Exception
     */
    public double dbb_2(double dft) throws Exception {
        double resultado = -1;
        try {
            resultado = dft * 2;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando dft entre polos abiertos.");
        }
        return resultado;
    }

    /**
     *
     * @param dbb_2
     * @param dft
     * @return
     * @throws Exception
     */
    public double distancia_dbb_2(double dbb_2, double dft) throws Exception {
        //dbb_1_8*2+dft*2+1
        double resultado = -1;
        try {
            resultado = dbb_2 * 2 + dft * 2 + 1;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando distancia de barra total con 2 .");
        }
        return resultado;
    }

    //ZONA DE TRABAJO VERTICAL PARA PERSONAS	
    /**
     *
     * @param dft
     * @return
     * @throws Exception
     */
    public double dvp(double dft) throws Exception {
        double resultado = -1;
        try {
            resultado = 2.3 + dft;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando DVP.");
        }
        return resultado;
    }

    /**
     *
     * @param dft
     * @return
     * @throws Exception
     */
    public double dhp(double dft) throws Exception {
        double resultado = -1;
        try {
            resultado = dft + 1.75;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando DHP.");
        }
        return resultado;
    }

    /**
     *
     * @param dhp
     * @param dft_polosAbiertos
     * @return
     * @throws Exception
     */
    public double dhp_seccionador_ct(double dhp, double dft_polosAbiertos) throws Exception {
        double resultado = -1;
        try {
            resultado = dhp - dft_polosAbiertos / 2;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando DHP Seccionador CT.");
        }
        return resultado;
    }

    /**
     *
     * @param dft
     * @param dft_polosAbiertos
     * @return
     * @throws Exception
     */
    public double seccionador_a_estruc(double dft, double dft_polosAbiertos) throws Exception {
        double resultado = -1;
        try {
            //E16+E21/2+0.5
            resultado = dft + dft_polosAbiertos / 2 + 0.5;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando Seccionador a Estruc.");
        }
        return resultado;
    }
    //DISTANCIA HORIZONTAL PARA CIRCULACION DE VEHICULOS				

    /**
     *
     * @param dft
     * @return
     * @throws Exception
     */
    public double dhv(double dft) throws Exception {
        double resultado = -1;
        try {
            resultado = 0.7 * dft;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando DHV.");
        }
        return resultado;
    }

    /**
     *
     * @param dft
     * @return
     * @throws Exception
     */
    public double dhvDeCalle(double dft) throws Exception {
        double resultado = -1;
        try {
            resultado = (0.7 + dft) * 2 + 2.5;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando DH de Calle.");
        }
        return resultado;
    }

    //DISTANCIA ENTRE PARARRAYOS Y PT
    /**
     *
     * @param dft
     * @return
     * @throws Exception
     */
    public double dp_pt(double dft) throws Exception {
        double resultado = -1;
        try {
            resultado = dft * 2;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando Distancia entre Pararrayos y PT.");
        }
        return resultado;
    }

    //DISTANCIA VERTICAL PARA CIRCULACION DE VEHICULOS
    /**
     *
     * @param dft
     * @return
     * @throws Exception
     */
    public double dvv(double dft) throws Exception {
        double resultado = -1;
        try {
            resultado = 0.5 + dft;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando Distancia Vertical para Circulacion de Vehiculos.");
        }
        return resultado;
    }

    //PRIMER NIVEL DE BARRAS O ALTURA DE EQUIPOS 	
    /**
     *
     * @param voltajeMaximo
     * @return
     * @throws Exception
     */
    public double he(double voltajeMaximo) throws Exception {
        double resultado = -1;
        try {
            resultado = 2.3 + 0.0105 * (voltajeMaximo);
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando Distancia Vertical para Circulacion de Vehiculos.");
        }
        return resultado;
    }

    /**
     *
     * @param he
     * @param msnm
     * @return
     * @throws Exception
     */
    public double he_msnm(double he, double msnm) throws Exception {
        double resultado = -1;
        try {
            resultado = he * (0.000125 * msnm + 0.875);
            if (resultado < 3) {
                //existe un error, 
                resultado = -1;
                throw new Exception("Error Calculando he. El resultado no puede ser menor a 3 metros.");
            }
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando HE.");
        }
        return resultado;
    }

    /**
     * 
     * @param voltajeMaximo
     * @return
     * @throws Exception 
     */
    public double hb(double voltajeMaximo) throws Exception {
        double resultado = -1;
        try {
            resultado = 5 + 0.0125 * voltajeMaximo;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando HB.");
        }
        return resultado;
    }

    //SEGUNDO NIVEL DE BARRAS O ALTURA MINIMA DE MONTAJE DE BARRAS	
    /**
     *
     * @param hb
     * @param msnm
     * @return
     * @throws Exception
     */
    public double hb_msnm(double hb, double msnm) throws Exception {
        double resultado = -1;
        try {
            resultado = hb * (0.000125 * msnm + 0.875);
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando hb(msnm).");
        }
        return resultado;
    }

    //ALTURA DE REMATE DE LINEAS QUE ENTRAN EN SUBESTACION
    /**
     *
     * @param kVmax
     * @return
     * @throws Exception
     */
    public double hl(double kVmax) throws Exception {
        double resultado = -1;
        try {
            resultado = 5 + 0.006 * kVmax;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando HL.");
        }
        return resultado;
    }

    /**
     *
     * @param hl
     * @param msnm
     * @return
     * @throws Exception
     */
    public double hl_msnm(double hl, double msnm) throws Exception {
        double resultado = -1;
        try {
            resultado = hl * (0.000125 * msnm + 0.875);
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando HL con metros sobre el nivel del mar.");
        }
        return resultado;
    }

    //ANCHO DE UN DIAMETRO	
    /**
     *
     * @param dft
     * @param dft_pa
     * @return
     * @throws Exception
     */
    public double A1_fi(double dft, double dft_pa) throws Exception {
        double resultado = -1;
        try {
            resultado = dft + (dft_pa / 2) + dft * 1.15 + (dft_pa / 2);
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando A1 Fi.");
        }
        return resultado;
    }

    /**
     *
     * @param A1_fi
     * @return
     * @throws Exception
     */
    public double At_fi(double A1_fi) throws Exception {
        double resultado = -1;
        try {
            resultado = 2 * A1_fi + 1;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando At Fi.");
        }
        return resultado;
    }

    //ANCHO TOTAL	
    /**
     *
     * @param At_fi
     * @param numeroDeDiametros
     * @return
     * @throws Exception
     */
    public double At(double At_fi, double numeroDeDiametros) throws Exception {
        double resultado = -1;
        try {
            resultado = At_fi * numeroDeDiametros + 1;
        } catch (Exception e) {
            resultado = -1;
            throw new Exception("Error Calculando At Fi.");
        }
        return resultado;
    }
    //    public static void main(String[] args) {
//        Calculos c = new Calculos();
//        try {
////            1. System.out.println("Resultado de Densidad: " + c.Densidad(18, 589));
////            2. System.out.println("DFT: " + c.dft(1050, 1, 1.1, 0.961, c.Densidad(18, 589)));
////            3. System.out.println("DFF: " + c.dff(c.dft(1050, 1, 1.1, 0.961, c.Densidad(18, 589))));
//            double dft = c.dft(1050, 1, c.Densidad(18, 589));
//            double dff = c.dff(dft);
////            4. System.out.println("Y: " + c.Y_FaseATierra_BilBasico(dff, dft));
//        } catch (Exception ex) {
//            Logger.getLogger(Calculos.class.getName()).log(Level.SEVERE, null, ex);
//        }
//    }
}
